// 修改日志系统
const logger = {
    debugEnabled: false,
    
    enableDebug() {
        this.debugEnabled = true;
        console.log('调试模式已开启');
    },
    
    disableDebug() {
        this.debugEnabled = false;
        console.log('调试模式已关闭');
    },
    
    debug(message, ...args) {
        if (this.debugEnabled) {
            console.log(`[DEBUG] ${message}`, ...args);
        }
    },
    
    info(message, ...args) {
        // 修改info方法，使其始终输出
        console.log(`[INFO] ${message}`, ...args);
    },
    
    error(message, ...args) {
        console.error(`[ERROR] ${message}`, ...args);
    },
    
    warn(message, ...args) {
        console.warn(`[WARN] ${message}`, ...args);
    }
};

// 在页面加载时立即输出一条信息
console.log('按键精灵 content script 已加载');

// 获取API配置
async function getApiConfig() {
    return new Promise((resolve) => {
        chrome.storage.sync.get(['apiKey', 'baseUrl'], (result) => {
            resolve({
                apiKey: result.apiKey,
                baseUrl: result.baseUrl || 'https://platform.moonshot.cn/v1'
            });
        });
    });
}

// 获取URL模式配置
async function getUrlPatterns() {
    try {
        const result = await chrome.storage.sync.get(['urlPatterns']);
        return result.urlPatterns || [];
    } catch (error) {
        logger.error('获取URL模式失败:', error);
        return [];
    }
}

// 检查URL是否匹配模式
function matchUrlPattern(url, pattern) {
    try {
        // 解析当前URL
        const currentUrlObj = new URL(url);
        
        // 处理模式URL
        let patternUrl = pattern;
        // 如果没有协议前缀，添加http://
        if (!pattern.startsWith('http://') && !pattern.startsWith('https://')) {
            patternUrl = 'http://' + pattern;
        }
        
        // 解析模式URL
        const patternUrlObj = new URL(patternUrl);
        
        // 比较主机名和端口
        const hostnameMatch = currentUrlObj.hostname === patternUrlObj.hostname;
        const portMatch = currentUrlObj.port === patternUrlObj.port || 
                         (currentUrlObj.port === '' && patternUrlObj.port === '') ||
                         (currentUrlObj.port === '80' && patternUrlObj.port === '') ||
                         (currentUrlObj.port === '443' && patternUrlObj.port === '');
        
        logger.debug(`URL匹配结果: ${hostnameMatch && portMatch}`);
        
        return hostnameMatch && portMatch;
    } catch (error) {
        logger.error('URL匹配错误:', error);
        return false;
    }
}

// 获取匹配的后端地址
async function getMatchingBackend(url) {
    const patterns = await getUrlPatterns();
    const matchingPattern = patterns.find(p => matchUrlPattern(url, p.pattern));
    return matchingPattern ? matchingPattern.backend : null;
}

// 调用Moonshot API
async function callMoonshotApi(prompt, retryCount = 0) {
    const MAX_RETRIES = 3; // 最大重试次数
    const RETRY_DELAYS = [3000, 5000, 10000]; // 重试延迟时间（毫秒）
    
    try {
        logger.debug('开始API调用:', prompt);
        
        // 直接从存储中获取API配置
        const config = await new Promise((resolve) => {
            chrome.storage.sync.get(['apiKey', 'baseUrl', 'modelName'], (result) => {
                resolve({
                    apiKey: result.apiKey,
                    baseUrl: result.baseUrl || 'https://api.moonshot.cn/v1',
                    modelName: result.modelName || 'moonshot-v1-8k'
                });
            });
        });
        
        if (!config.apiKey) {
            throw new Error('未配置API密钥，请在设置中配置API密钥');
        }

        if (!config.baseUrl) {
            throw new Error('未配置基础URL，请在设置中配置基础URL');
        }

        // 发送API请求
        const response = await fetch(`${config.baseUrl}/chat/completions`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${config.apiKey}`
            },
            body: JSON.stringify({
                model: config.modelName,
                messages: [
                    {
                        role: "user",
                        content: prompt
                    }
                ],
                temperature: 0.7,
                max_tokens: 2000
            }),
            mode: 'cors' // 使用CORS模式，但不发送OPTIONS请求
        });

        // 处理429状态码（请求过于频繁）
        if (response.status === 429) {
            if (retryCount >= MAX_RETRIES) {
                throw new Error('达到最大重试次数，请稍后再试');
            }
            
            const delay = RETRY_DELAYS[retryCount] || RETRY_DELAYS[RETRY_DELAYS.length - 1];
            logger.info(`请求过于频繁，等待${delay/1000}秒后重试... (第${retryCount + 1}次重试)`);
            await new Promise(resolve => setTimeout(resolve, delay));
            return callMoonshotApi(prompt, retryCount + 1); // 递归重试
        }

        if (!response.ok) {
            const errorText = await response.text();
            logger.error('API错误响应:', errorText);
            throw new Error(`API调用失败: ${response.status} - ${errorText}`);
        }

        const data = await response.json();
        logger.debug('API响应:', data);
        
        if (!data.choices || !data.choices[0] || !data.choices[0].message) {
            throw new Error('API响应格式错误');
        }
        
        return data.choices[0].message.content;
    } catch (error) {
        logger.error('API调用失败:', error);
        throw new Error(`API调用失败: ${error.message}`);
    }
}

// 获取匹配的按钮配置
async function getMatchingButtons(url) {
    const patterns = await getUrlPatterns();
    return patterns.filter(p => matchUrlPattern(url, p.pattern));
}

// 获取页面数据
async function getPageData() {
    const url = window.location.href;
    
    // 获取当前页面可访问的cookie（原始格式）
    const rawCookies = document.cookie;
    logger.debug('获取到页面cookie原始文本:', rawCookies);
    
    // 将cookie字符串解析为对象数组 (仅用于日志和其他用途)
    const cookiesArray = rawCookies.split(';').map(cookie => {
        const parts = cookie.trim().split('=');
        return {
            name: parts[0],
            value: parts.length > 1 ? parts[1] : ''
        };
    });
    
    logger.info(`获取到${cookiesArray.length}个cookie`);
    
    return {
        url,
        cookies: cookiesArray,          // 解析后的cookie数组 (用于兼容)
        rawCookies: rawCookies,         // 原始cookie字符串 (用于发送)
        content: getPageContent(),
        html: getPageHTML()
    };
}

// 获取页面文本内容
function getPageContent() {
    // 获取所有文本节点
    const textNodes = [];
    const walk = document.createTreeWalker(
        document.body,
        NodeFilter.SHOW_TEXT,
        {
            acceptNode: function(node) {
                // 排除脚本和样式标签中的文本
                if (node.parentElement.tagName === 'SCRIPT' || 
                    node.parentElement.tagName === 'STYLE') {
                    return NodeFilter.FILTER_REJECT;
                }
                // 排除空白文本
                if (!node.textContent.trim()) {
                    return NodeFilter.FILTER_REJECT;
                }
                return NodeFilter.FILTER_ACCEPT;
            }
        }
    );
    
    let node;
    while (node = walk.nextNode()) {
        textNodes.push(node.textContent.trim());
    }
    
    // 合并文本并限制长度
    return textNodes.join('\n').substring(0, 4000);
}

// 获取页面完整HTML
function getPageHTML() {
    return document.documentElement.outerHTML;
}

// 向后台脚本发送消息的辅助函数
function sendToBackground(message) {
    return new Promise((resolve, reject) => {
        try {
            // 首先检查扩展是否正常连接
            if (!chrome.runtime) {
                logger.error('chrome.runtime 不可用');
                reject(new Error('扩展运行时不可用，请刷新页面'));
                return;
            }
            
            chrome.runtime.sendMessage(message, response => {
                // 检查扩展是否发生错误
                if (chrome.runtime.lastError) {
                    logger.error('发送消息失败:', chrome.runtime.lastError);
                    reject(new Error('发送消息失败: ' + chrome.runtime.lastError.message));
                    return;
                }
                
                // 检查响应
                if (!response) {
                    logger.debug('消息已发送，但未收到响应');
                    resolve(null); // 假设成功但没有数据
                    return;
                }
                
                resolve(response);
            });
        } catch (error) {
            logger.error('发送消息过程中出错:', error);
            reject(error);
        }
    });
}

// 修改sendDataToBackend函数，确保正确处理HTTPOnly cookies
async function sendDataToBackend(data, config) {
    return new Promise((resolve, reject) => {
        logger.debug('开始准备发送数据到后端');
        
        try {
            // 确保URL是有效的
            const url = config.backendUrl;
            const normalizedUrl = (!url.startsWith('http://') && !url.startsWith('https://')) ? 
                `http://${url}` : url;
                
            // 获取当前页面URL作为Referer
            const currentPageUrl = window.location.href;
            logger.debug('当前页面URL (Referer):', currentPageUrl);
            logger.debug('准备发送POST请求到:', normalizedUrl);
            
            // 准备要发送的原始数据
            let rawData = '';
            if (config.contentType === 'custom') {
                rawData = config.customText || '';
            } else if (config.contentType === 'pageContent') {
                rawData = data.html || data.content || '';
            } else if (config.contentType === 'cookies') {
                // 检查是否有从background.js接收到的HTTPOnly cookies
                if (config.allCookies && Array.isArray(config.allCookies)) {
                    // 格式化所有cookie（包括HTTPOnly），但不添加HTTPOnly标识
                    const cookieStrings = config.allCookies.map(cookie => 
                        `${cookie.name}=${cookie.value}`
                    );
                    rawData = cookieStrings.join('; ');
                    logger.info(`使用background.js提供的${config.allCookies.length}个cookie（包括HTTPOnly，但无特殊标识）`);
                } else {
                    // 回退到普通cookie
                    rawData = data.rawCookies || document.cookie || '';
                    logger.info('仅使用普通cookie (无HTTPOnly)');
                }
                logger.debug('使用cookie文本:', rawData);
            }
            
            logger.debug(`数据准备完成，长度: ${rawData.length} 字节`);
            
            // 使用fetch API发送请求，使用no-cors模式
            fetch(normalizedUrl, {
                method: 'POST',
                headers: {
                    'Content-Type': 'text/plain',
                    'X-Requested-With': 'XMLHttpRequest',
                    // 添加来源URL信息
                    // 注意：浏览器在no-cors模式下可能会限制某些自定义头部
                    'Referer': currentPageUrl,
                    'X-Source-Url': currentPageUrl // 自定义头，以防Referer被限制
                },
                body: rawData,
                mode: 'no-cors', // 关键设置: 使用no-cors模式避免CORS问题
                referrer: currentPageUrl, // 直接设置fetch API的referrer属性
                referrerPolicy: 'unsafe-url' // 确保发送完整的referrer
            }).then(response => {
                logger.info('请求已发送成功');
                // 由于使用no-cors模式，无法读取响应内容，只能确认请求已发送
                resolve({
                    success: true,
                    message: '请求已发送（no-cors模式，无法获取服务器响应）'
                });
            }).catch(error => {
                logger.error('发送请求失败:', error);
                reject(new Error('发送请求失败: ' + error.message));
            });
            
        } catch (error) {
            logger.error('整体异常:', error);
            reject(error);
        }
    });
}

// 创建自定义按钮
function createCustomButton(config) {
    const button = document.createElement('button');
    button.textContent = config.buttonName;
    button.style.cssText = `
        position: fixed;
        right: 20px;
        bottom: 20px;
        padding: 10px 20px;
        background-color: #4CAF50;
        color: white;
        border: none;
        border-radius: 4px;
        cursor: pointer;
        z-index: 10000;
        margin: 5px;
    `;
    
    button.onclick = async () => {
        try {
            const pageData = await getPageData();
            await sendDataToBackend(pageData, config);
            alert('数据发送成功！');
        } catch (error) {
            alert('发送失败：' + error.message);
        }
    };
    
    return button;
}

// 初始化自定义按钮
async function initializeCustomButtons() {
    // 禁用创建按钮，仅保留右键菜单功能
    logger.debug('已禁用页面右下角的自定义按钮，仅使用右键菜单');
    return;
}

// 修改初始化逻辑
function initialize() {
    logger.info('开始初始化content script');
    
    // 检查chrome.runtime是否可用
    if (typeof chrome === 'undefined' || !chrome.runtime) {
        logger.error('chrome.runtime 不可用，扩展可能未正确加载');
        return;
    }
    
    // 检查chrome.runtime.id是否可用
    if (!chrome.runtime.id) {
        logger.error('chrome.runtime.id 不可用，扩展可能未正确加载');
        return;
    }
    
    // 发送ping消息检查连接
    chrome.runtime.sendMessage({ action: 'ping' }, response => {
        if (chrome.runtime.lastError) {
            logger.error('ping失败:', chrome.runtime.lastError);
            // 尝试重新初始化
            setTimeout(() => {
                logger.info('尝试重新初始化...');
                initialize();
            }, 1000);
            return;
        }
        
        logger.info('扩展连接正常，开始初始化功能');
        
        // 初始化自定义按钮
        initializeCustomButtons();
        
        // 设置快捷键监听器
        setupKeyboardListener();
        
        // 设置右键菜单
        createContextMenu();
    });
}

// 页面加载完成后初始化
if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', () => {
        logger.debug('DOMContentLoaded 事件触发');
        initialize();
    });
} else {
    logger.debug('页面已加载，直接初始化');
    initialize();
}

// 创建翻译弹窗
function createTranslationPopup(text) {
    const popup = document.createElement('div');
    popup.style.cssText = `
        position: fixed;
        top: 50%;
        left: 50%;
        transform: translate(-50%, -50%);
        background: white;
        padding: 20px;
        border-radius: 8px;
        box-shadow: 0 2px 10px rgba(0,0,0,0.1);
        z-index: 10000;
        max-width: 80%;
        max-height: 80vh;
        overflow-y: auto;
    `;
    
    const closeBtn = document.createElement('button');
    closeBtn.textContent = '×';
    closeBtn.style.cssText = `
        position: absolute;
        top: 10px;
        right: 10px;
        border: none;
        background: none;
        font-size: 20px;
        cursor: pointer;
        color: #666;
        padding: 5px;
        line-height: 1;
    `;
    
    const content = document.createElement('div');
    content.style.marginTop = '20px';
    content.style.maxHeight = 'calc(80vh - 60px)';
    content.style.overflowY = 'auto';
    
    popup.appendChild(closeBtn);
    popup.appendChild(content);
    document.body.appendChild(popup);
    
    closeBtn.onclick = () => popup.remove();
    
    return content;
}

// 翻译文本
async function translateText(text) {
    const prompt = `请将以下文本翻译成中文：\n${text}`;
    return await callMoonshotApi(prompt);
}

// 总结文本
async function summarizeText(text) {
    const prompt = `请总结以下文本的主要内容：\n${text}`;
    return await callMoonshotApi(prompt);
}

// 翻译并总结
async function translateAndSummarize(text) {
    const prompt = `请先总结以下文本的主要内容，然后将其翻译成中文：\n${text}`;
    return await callMoonshotApi(prompt);
}

// 替换页面内容
async function replacePageContent(originalContent, translatedContent) {
    // 创建翻译样式
    const style = document.createElement('style');
    style.textContent = `
        .translation-original {
            color: #495057;
            margin-bottom: 10px;
            padding-right: 10px;
            border-right: 2px solid #dee2e6;
        }
        
        .translation-translated {
            color: #212529;
            padding-left: 10px;
            border-left: 2px solid #4CAF50;
            display: none;
        }
        
        .translation-visible .translation-translated {
            display: block;
        }
        
        .translation-toggle {
            position: absolute;
            top: 10px;
            right: 10px;
            background: none;
            border: none;
            color: #6c757d;
            cursor: pointer;
            font-size: 14px;
            padding: 4px 8px;
            border-radius: 4px;
        }
        
        .translation-toggle:hover {
            background: #e9ecef;
        }
    `;
    document.head.appendChild(style);
    
    // 获取所有需要翻译的元素
    const elements = document.querySelectorAll('p, h1, h2, h3, h4, h5, h6');
    
    // 逐个翻译元素
    for (const element of elements) {
        try {
            const text = element.textContent.trim();
            if (!text) continue;
            
            // 保存原始样式
            const originalStyles = window.getComputedStyle(element);
            const styleMap = new Map();
            for (const prop of originalStyles) {
                styleMap.set(prop, originalStyles.getPropertyValue(prop));
            }
            
            // 创建包装器
            const wrapper = document.createElement('div');
            wrapper.style.cssText = `
                position: relative;
                margin: 10px 0;
                padding: 10px;
                background: #f8f9fa;
                border-radius: 4px;
            `;
            
            // 创建原文元素
            const originalDiv = document.createElement(element.tagName.toLowerCase());
            originalDiv.className = 'translation-original';
            originalDiv.textContent = text;
            
            // 应用原始样式
            for (const [prop, value] of styleMap) {
                originalDiv.style[prop] = value;
            }
            
            // 翻译文本
            const translatedText = await translateText(text);
            
            // 创建译文元素
            const translatedDiv = document.createElement(element.tagName.toLowerCase());
            translatedDiv.className = 'translation-translated';
            translatedDiv.textContent = translatedText;
            
            // 应用原始样式
            for (const [prop, value] of styleMap) {
                translatedDiv.style[prop] = value;
            }
            
            // 创建切换按钮
            const toggleBtn = document.createElement('button');
            toggleBtn.className = 'translation-toggle';
            toggleBtn.textContent = '显示/隐藏译文';
            toggleBtn.onclick = () => {
                wrapper.classList.toggle('translation-visible');
            };
            
            // 替换原始元素
            wrapper.appendChild(originalDiv);
            wrapper.appendChild(translatedDiv);
            wrapper.appendChild(toggleBtn);
            element.parentNode.replaceChild(wrapper, element);
            
            // 添加延迟以避免请求过于频繁
            await new Promise(resolve => setTimeout(resolve, 1000));
            
        } catch (error) {
            logger.error('翻译元素失败:', error);
        }
    }
}

// 监听来自background script的消息
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
    logger.debug('收到消息:', request.action);
    
    // 立即发送初始响应，避免连接关闭
    try {
        sendResponse({ received: true });
    } catch (error) {
        logger.error('发送响应失败:', error);
    }

    // 使用请求ID防止重复处理
    const requestId = request.requestId || Date.now() + '-' + Math.random().toString(36).substr(2, 9);
    
    // 检查是否已经处理过这个请求
    window._processedRequests = window._processedRequests || {};
    if (window._processedRequests[requestId]) {
        logger.debug('请求已被处理过，跳过:', requestId);
        return true;
    }
    
    // 记录这个请求已被处理
    window._processedRequests[requestId] = true;
    
    try {
        if (!request || !request.action) {
            logger.error('收到无效消息，缺少action字段');
            return true;
        }
        
        switch (request.action) {
            case 'translatePage':
                translatePage()
                    .catch(error => logger.error('翻译页面操作失败:', error));
                break;
                
            case 'summarizePage':
                summarizePage()
                    .catch(error => logger.error('总结页面操作失败:', error));
                break;
                
            case 'summarizeAndTranslate':
                summarizeAndTranslate()
                    .catch(error => logger.error('翻译并总结操作失败:', error));
                break;
                
            case 'sendPageData':
                if (!request.config) {
                    logger.error('发送页面数据失败: 缺少配置信息');
                    return true;
                }
                
                // 增加timeout后清理已处理请求记录
                setTimeout(() => {
                    if (window._processedRequests[requestId]) {
                        delete window._processedRequests[requestId];
                    }
                }, 10000); // 10秒后清理，允许新的请求
                
                sendPageData(request.config)
                    .catch(error => logger.error('发送页面数据操作失败:', error));
                break;
                
            case 'handleShortcut':
                if (!request.pattern) {
                    logger.error('处理快捷键失败: 缺少pattern信息');
                    return true;
                }
                
                // 获取页面数据
                getPageData().then(pageData => {
                    // 根据配置的内容类型发送数据
                    const config = {
                        backendUrl: request.pattern.backendUrl,
                        contentType: request.pattern.contentType || 'cookies',
                        customText: request.pattern.customText,
                        // 重要:添加allCookies字段
                        allCookies: request.allCookies
                    };
                    
                    logger.debug('快捷键发送配置:', config);
                    logger.debug('是否有HTTPOnly cookies:', request.allCookies ? `有,共${request.allCookies.length}个` : '无');
                    
                    sendDataToBackend(pageData, config)
                        .then(() => {
                            logger.info('快捷键触发成功，数据已发送');
                        })
                        .catch(error => {
                            logger.error('发送数据失败:', error);
                            alert('发送数据失败：' + error.message);
                        });
                }).catch(error => {
                    logger.error('获取页面数据失败:', error);
                });
                break;
                
            case 'directSendRequest':
                // 处理直接发送请求的消息
                if (!request.url) {
                    logger.error('直接发送请求失败: 缺少URL');
                    return false; // 同步响应，不保持消息通道开放
                }
                
                logger.debug('接收到直接发送请求:', request.url);
                
                // 直接调用处理函数
                handleDirectSendRequest({
                    url: request.url,
                    data: request.data
                })
                .then(response => {
                    logger.debug('直接发送请求成功:', response);
                    try {
                        // 发送响应结果到background.js
                        chrome.runtime.sendMessage({
                            action: 'directSendResponse',
                            requestId: request.requestId,
                            success: true,
                            response: response
                        });
                    } catch (error) {
                        logger.error('发送响应结果失败:', error);
                    }
                })
                .catch(error => {
                    logger.error('直接发送请求失败:', error);
                    try {
                        // 发送错误结果到background.js
                        chrome.runtime.sendMessage({
                            action: 'directSendResponse',
                            requestId: request.requestId,
                            success: false,
                            error: error.message
                        });
                    } catch (sendError) {
                        logger.error('发送错误结果失败:', sendError);
                    }
                });
                
                // 返回false，不保持消息通道开放
                return false;
                
            default:
                logger.warn('未知的消息类型:', request.action);
        }
    } catch (error) {
        logger.error('处理消息时出错:', error);
    }
    
    // 返回true保持消息通道开放
    return true;
});

// 翻译页面
async function translatePage() {
    try {
        const content = getPageContent();
        const translatedContent = await translateText(content);
        await replacePageContent(content, translatedContent);
    } catch (error) {
        logger.error('翻译页面失败:', error);
        alert('翻译失败：' + error.message);
    }
}

// 总结页面
async function summarizePage() {
    try {
        const content = getPageContent();
        const summary = await summarizeText(content);
        const popup = createTranslationPopup(content);
        popup.textContent = summary;
    } catch (error) {
        logger.error('总结页面失败:', error);
        alert('总结失败：' + error.message);
    }
}

// 翻译并总结
async function summarizeAndTranslate() {
    try {
        const content = getPageContent();
        const result = await translateAndSummarize(content);
        await replacePageContent(content, result);
    } catch (error) {
        logger.error('翻译并总结失败:', error);
        alert('操作失败：' + error.message);
    }
}

// 修改sendPageData函数，添加对HTTPOnly cookies的支持
async function sendPageData(config) {
    try {
        // 直接获取页面数据并发送
        const pageData = await getPageData();
        logger.debug('发送数据到:', config.backendUrl);
        logger.debug('内容类型:', config.contentType);
        
        try {
            // 如果配置中包含HTTPOnly cookies，使用它们
            if (config.contentType === 'cookies' && config.allCookies) {
                logger.debug(`使用包含HTTPOnly的完整cookie列表，数量: ${config.allCookies.length}`);
            }
            
            // 直接调用sendDataToBackend
            const result = await sendDataToBackend(pageData, config);
            logger.debug('数据发送结果:', result);
            return result;
        } catch (error) {
            logger.error('发送数据失败:', error.message);
            throw error;
        }
    } catch (error) {
        logger.error('准备或发送数据失败:', error.message);
        throw error;
    }
}

// 创建右键菜单的空实现
function createContextMenu() {
    logger.debug('createContextMenu被调用，但不再创建自定义右键菜单');
}

// 输出调试模式说明
logger.info('如需开启调试日志，请在控制台执行: logger.enableDebug()');

// 修改checkExtensionContext函数
function checkExtensionContext() {
    return new Promise((resolve) => {
        try {
            // 首先检查chrome.runtime是否存在
            if (typeof chrome === 'undefined' || !chrome.runtime) {
                logger.error('chrome.runtime 不存在，扩展可能未正确加载');
                resolve(false);
                return;
            }

            // 检查chrome.runtime.id是否存在
            if (!chrome.runtime.id) {
                logger.error('chrome.runtime.id 不存在，扩展可能未正确加载');
                resolve(false);
                return;
            }

            // 尝试发送ping消息
            chrome.runtime.sendMessage({ action: 'ping' }, response => {
                if (chrome.runtime.lastError) {
                    logger.error('ping失败:', chrome.runtime.lastError);
                    // 尝试重新注入content script
                    chrome.runtime.sendMessage({ action: 'reloadContentScript' }, reloadResponse => {
                        if (chrome.runtime.lastError) {
                            logger.error('重新注入content script失败:', chrome.runtime.lastError);
                            resolve(false);
                        } else {
                            logger.info('content script重新注入成功');
                            resolve(true);
                        }
                    });
                } else {
                    resolve(true);
                }
            });
        } catch (error) {
            logger.error('检查扩展上下文时出错:', error);
            resolve(false);
        }
    });
}

// 修改setupKeyboardListener函数
function setupKeyboardListener() {
    logger.debug('初始化快捷键监听器');
    
    // 添加重试机制
    let retryCount = 0;
    const MAX_RETRIES = 3;
    const RETRY_DELAY = 1000; // 1秒
    
    document.addEventListener('keydown', async (event) => {
        try {
            // 首先检查当前URL是否匹配任何配置的网站模式
            const currentUrl = window.location.href;
            const patterns = await getUrlPatterns();
            const isMatchingUrl = patterns.some(pattern => matchUrlPattern(currentUrl, pattern.pattern));
            
            if (!isMatchingUrl) {
                logger.debug('当前URL不匹配任何配置的网站模式，忽略快捷键');
                return; // 不匹配任何模式，直接返回
            }
            
            // 构建快捷键字符串
            const modifiers = [];
            if (event.ctrlKey) modifiers.push('Ctrl');
            if (event.shiftKey) modifiers.push('Shift');
            if (event.altKey) modifiers.push('Alt');
            if (event.metaKey) modifiers.push('Meta');
            
            // 添加主键（如果不是修饰键）
            const key = event.key.toLowerCase(); // 转换为小写
            if (!['control', 'shift', 'alt', 'meta'].includes(key)) {
                modifiers.push(key);
            }
            
            const shortcut = modifiers.join('+');
            logger.debug('检测到快捷键:', shortcut);
            
            // 检查扩展上下文是否有效
            if (!chrome.runtime || !chrome.runtime.id) {
                logger.error('扩展上下文已失效，尝试重新初始化');
                if (retryCount < MAX_RETRIES) {
                    retryCount++;
                    logger.debug(`等待${RETRY_DELAY/1000}秒后重试 (${retryCount}/${MAX_RETRIES})`);
                    await new Promise(resolve => setTimeout(resolve, RETRY_DELAY));
                    return;
                } else {
                    logger.error('达到最大重试次数，请刷新页面');
                    alert('扩展上下文已失效，请刷新页面');
                    return;
                }
            }
            
            // 重置重试计数
            retryCount = 0;
            
            // 检查快捷键是否匹配
            logger.debug('发送快捷键检查请求:', shortcut);
            
            // 直接发送请求，不设置超时
            const response = await new Promise((resolve) => {
                chrome.runtime.sendMessage({
                    action: 'checkShortcut',
                    shortcut: shortcut
                }, (response) => {
                    if (chrome.runtime.lastError) {
                        logger.error('检查快捷键失败:', chrome.runtime.lastError);
                        resolve(null);
                    } else {
                        logger.debug('收到快捷键检查响应:', response);
                        resolve(response);
                    }
                });
            });
            
            if (response && response.found) {
                logger.debug('找到匹配的快捷键配置:', response.pattern);
                // 阻止默认行为
                event.preventDefault();
                
                try {
                    // 修改：不在这里直接发送数据，而是请求background.js来处理，以便获取HTTPOnly cookies
                    logger.debug('请求background.js处理快捷键，获取HTTPOnly cookies');
                    chrome.runtime.sendMessage({
                        action: 'handleKeyboardShortcut',
                        pattern: response.pattern,
                        shortcut: shortcut
                    }, (handleResponse) => {
                        if (chrome.runtime.lastError) {
                            logger.error('请求处理快捷键失败:', chrome.runtime.lastError);
                        } else {
                            logger.debug('快捷键处理请求已发送');
                        }
                    });
                } catch (error) {
                    logger.error('处理快捷键失败:', error);
                    alert('处理快捷键失败：' + error.message);
                }
            } else {
                logger.debug('未找到匹配的快捷键配置');
                // 调试信息
                chrome.storage.sync.get(['urlPatterns'], (result) => {
                    logger.debug('当前保存的配置:', result.urlPatterns || []);
                });
            }
        } catch (error) {
            logger.error('快捷键处理失败:', error);
            if (error.message.includes('Extension context invalidated')) {
                alert('扩展上下文已失效，请刷新页面');
            }
        }
    });
}

// 添加直接发送请求的处理程序
function handleDirectSendRequest(request) {
    return new Promise((resolve, reject) => {
        try {
            // 获取当前页面URL作为Referer
            const currentPageUrl = window.location.href;
            logger.debug('直接发送请求:', request.url);
            logger.debug('当前页面URL (Referer):', currentPageUrl);
            logger.debug('数据长度:', request.data ? request.data.length : 0);
            
            // 使用XMLHttpRequest发送请求，避免OPTIONS预检请求
            const xhr = new XMLHttpRequest();
            xhr.open('POST', request.url, true);
            
            // 设置内容类型为表单格式，避免预检请求
            xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
            
            // 设置请求超时
            xhr.timeout = 30000; // 30秒
            
            // 设置回调
            xhr.onreadystatechange = function() {
                if (xhr.readyState === 4) {
                    logger.debug('请求完成，状态:', xhr.status);
                    if (xhr.status >= 200 && xhr.status < 300) {
                        // 成功处理响应
                        resolve({
                            success: true,
                            status: xhr.status,
                            text: xhr.responseText
                        });
                    } else {
                        // 请求失败
                        reject(new Error(`请求失败: ${xhr.status} - ${xhr.statusText || '未知错误'}`));
                    }
                }
            };
            
            // 错误处理
            xhr.onerror = function(error) {
                logger.error('请求出错:', error);
                reject(new Error('网络请求失败'));
            };
            
            xhr.ontimeout = function() {
                logger.error('请求超时');
                reject(new Error('请求超时'));
            };
            
            // 构建表单数据，确保能在后端接收
            let formData;
            
            if (request.data && typeof request.data === 'string') {
                // 如果已有数据，将其作为data参数发送
                formData = `data=${encodeURIComponent(request.data)}&referer=${encodeURIComponent(currentPageUrl)}`;
            } else {
                // 否则只发送referer参数
                formData = `referer=${encodeURIComponent(currentPageUrl)}`;
            }
            
            logger.debug('准备发送表单数据:', formData.substring(0, 100) + '...');
            
            // 发送请求 - 浏览器会自动设置Referer头，但我们也在表单中传递
            logger.debug('正在发送XMLHttpRequest请求...');
            xhr.send(formData);
        } catch (error) {
            logger.error('发送请求时发生错误:', error);
            reject(error);
        }
    });
}